package co.edu.usbcali.presentation.businessDelegate;

import co.edu.usbcali.modelo.ActaEvaluacion;
import co.edu.usbcali.modelo.ActaInicio;
import co.edu.usbcali.modelo.ActaSeguimiento;
import co.edu.usbcali.modelo.ActaSupervision;
import co.edu.usbcali.modelo.Administrador;
import co.edu.usbcali.modelo.Archivo;
import co.edu.usbcali.modelo.AreaDesempeno;
import co.edu.usbcali.modelo.Cuenta;
import co.edu.usbcali.modelo.Docente;
import co.edu.usbcali.modelo.Empresa;
import co.edu.usbcali.modelo.Inscripcion;
import co.edu.usbcali.modelo.Practicante;
import co.edu.usbcali.modelo.Preinscripcion;
import co.edu.usbcali.modelo.ProgramaAcademico;
import co.edu.usbcali.modelo.control.ActaEvaluacionLogic;
import co.edu.usbcali.modelo.control.ActaInicioLogic;
import co.edu.usbcali.modelo.control.ActaSeguimientoLogic;
import co.edu.usbcali.modelo.control.ActaSupervisionLogic;
import co.edu.usbcali.modelo.control.AdministradorLogic;
import co.edu.usbcali.modelo.control.ArchivoLogic;
import co.edu.usbcali.modelo.control.AreaDesempenoLogic;
import co.edu.usbcali.modelo.control.CuentaLogic;
import co.edu.usbcali.modelo.control.DocenteLogic;
import co.edu.usbcali.modelo.control.EmpresaLogic;
import co.edu.usbcali.modelo.control.IActaEvaluacionLogic;
import co.edu.usbcali.modelo.control.IActaInicioLogic;
import co.edu.usbcali.modelo.control.IActaSeguimientoLogic;
import co.edu.usbcali.modelo.control.IActaSupervisionLogic;
import co.edu.usbcali.modelo.control.IAdministradorLogic;
import co.edu.usbcali.modelo.control.IArchivoLogic;
import co.edu.usbcali.modelo.control.IAreaDesempenoLogic;
import co.edu.usbcali.modelo.control.ICuentaLogic;
import co.edu.usbcali.modelo.control.IDocenteLogic;
import co.edu.usbcali.modelo.control.IEmpresaLogic;
import co.edu.usbcali.modelo.control.IInscripcionLogic;
import co.edu.usbcali.modelo.control.IPracticanteLogic;
import co.edu.usbcali.modelo.control.IPreinscripcionLogic;
import co.edu.usbcali.modelo.control.IProgramaAcademicoLogic;
import co.edu.usbcali.modelo.control.InscripcionLogic;
import co.edu.usbcali.modelo.control.PracticanteLogic;
import co.edu.usbcali.modelo.control.PreinscripcionLogic;
import co.edu.usbcali.modelo.control.ProgramaAcademicoLogic;

import java.math.BigDecimal;

import java.util.Date;
import java.util.List;
import java.util.Set;


/**
* Use a Business Delegate to reduce coupling between presentation-tier clients and business services.
* The Business Delegate hides the underlying implementation details of the business service, such as lookup and access details of the EJB architecture.
*
* The Business Delegate acts as a client-side business abstraction; it provides an abstraction for, and thus hides,
* the implementation of the business services. Using a Business Delegate reduces the coupling between presentation-tier clients and
* the system's business services. Depending on the implementation strategy, the Business Delegate may shield clients from possible
* volatility in the implementation of the business service API. Potentially, this reduces the number of changes that must be made to the
* presentation-tier client code when the business service API or its underlying implementation changes.
*
* However, interface methods in the Business Delegate may still require modification if the underlying business service API changes.
* Admittedly, though, it is more likely that changes will be made to the business service rather than to the Business Delegate.
*
* Often, developers are skeptical when a design goal such as abstracting the business layer causes additional upfront work in return
* for future gains. However, using this pattern or its strategies results in only a small amount of additional upfront work and provides
* considerable benefits. The main benefit is hiding the details of the underlying service. For example, the client can become transparent
* to naming and lookup services. The Business Delegate also handles the exceptions from the business services, such as java.rmi.Remote
* exceptions, Java Messages Service (JMS) exceptions and so on. The Business Delegate may intercept such service level exceptions and
* generate application level exceptions instead. Application level exceptions are easier to handle by the clients, and may be user friendly.
* The Business Delegate may also transparently perform any retry or recovery operations necessary in the event of a service failure without
* exposing the client to the problem until it is determined that the problem is not resolvable. These gains present a compelling reason to
* use the pattern.
*
* Another benefit is that the delegate may cache results and references to remote business services. Caching can significantly improve performance,
* because it limits unnecessary and potentially costly round trips over the network.
*
* A Business Delegate uses a component called the Lookup Service. The Lookup Service is responsible for hiding the underlying implementation
* details of the business service lookup code. The Lookup Service may be written as part of the Delegate, but we recommend that it be
* implemented as a separate component, as outlined in the Service Locator pattern (See "Service Locator" on page 368.)
*
* When the Business Delegate is used with a Session Facade, typically there is a one-to-one relationship between the two.
* This one-to-one relationship exists because logic that might have been encapsulated in a Business Delegate relating to its interaction
* with multiple business services (creating a one-to-many relationship) will often be factored back into a Session Facade.
*
* Finally, it should be noted that this pattern could be used to reduce coupling between other tiers, not simply the presentation and the
* business tiers.
*
* @author Zathura Code Generator http://code.google.com/p/zathura
*
*/
public class BusinessDelegatorView {
    private BusinessDelegatorView() {
    }

    public static List<ActaEvaluacion> getActaEvaluacion()
        throws Exception {
        IActaEvaluacionLogic actaEvaluacionLogic = new ActaEvaluacionLogic();

        return actaEvaluacionLogic.getActaEvaluacion();
    }

    public static void saveActaEvaluacion(Double calAvg, Long calCinco,
        Long calCuatro, Long calDiez, Long calDoce, Long calDos, Long calNueve,
        Long calOcho, Long calOnce, Long calSeis, Long calSiete, Long calTrece,
        Long calTres, Long calUno, String caracterizacionEv,
        String debilidadEv, Date fechaEv, String fortalezaEv,
        Long codPra_Practicante) throws Exception {
        IActaEvaluacionLogic actaEvaluacionLogic = new ActaEvaluacionLogic();
        actaEvaluacionLogic.saveActaEvaluacion(calAvg, calCinco, calCuatro,
            calDiez, calDoce, calDos, calNueve, calOcho, calOnce, calSeis,
            calSiete, calTrece, calTres, calUno, caracterizacionEv,
            debilidadEv, fechaEv, fortalezaEv, codPra_Practicante);
    }

    public static void deleteActaEvaluacion(Long codEv)
        throws Exception {
        IActaEvaluacionLogic actaEvaluacionLogic = new ActaEvaluacionLogic();
        actaEvaluacionLogic.deleteActaEvaluacion(codEv);
    }

    public static void updateActaEvaluacion(Double calAvg, Long calCinco,
        Long calCuatro, Long calDiez, Long calDoce, Long calDos, Long calNueve,
        Long calOcho, Long calOnce, Long calSeis, Long calSiete, Long calTrece,
        Long calTres, Long calUno, String caracterizacionEv, Long codEv,
        String debilidadEv, Date fechaEv, String fortalezaEv,
        Long codPra_Practicante) throws Exception {
        IActaEvaluacionLogic actaEvaluacionLogic = new ActaEvaluacionLogic();
        actaEvaluacionLogic.updateActaEvaluacion(calAvg, calCinco, calCuatro,
            calDiez, calDoce, calDos, calNueve, calOcho, calOnce, calSeis,
            calSiete, calTrece, calTres, calUno, caracterizacionEv, codEv,
            debilidadEv, fechaEv, fortalezaEv, codPra_Practicante);
    }

    public static ActaEvaluacion getActaEvaluacion(Long codEv)
        throws Exception {
        IActaEvaluacionLogic actaEvaluacionLogic = new ActaEvaluacionLogic();
        ActaEvaluacion actaEvaluacion = null;

        try {
            actaEvaluacion = actaEvaluacionLogic.getActaEvaluacion(codEv);
        } catch (Exception e) {
            throw e;
        }

        return actaEvaluacion;
    }

    public static List<ActaEvaluacion> findByCriteriaInActaEvaluacion(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IActaEvaluacionLogic actaEvaluacionLogic = new ActaEvaluacionLogic();

        return actaEvaluacionLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<ActaEvaluacion> findPageActaEvaluacion(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IActaEvaluacionLogic actaEvaluacionLogic = new ActaEvaluacionLogic();

        return actaEvaluacionLogic.findPageActaEvaluacion(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberActaEvaluacion()
        throws Exception {
        IActaEvaluacionLogic actaEvaluacionLogic = new ActaEvaluacionLogic();

        return actaEvaluacionLogic.findTotalNumberActaEvaluacion();
    }

    public static List<ActaInicio> getActaInicio() throws Exception {
        IActaInicioLogic actaInicioLogic = new ActaInicioLogic();

        return actaInicioLogic.getActaInicio();
    }

    public static void saveActaInicio(String diasIni,
        Date fechaIni, String funcionesIni, Long horasIni,
        Long codPra_Practicante) throws Exception {
        IActaInicioLogic actaInicioLogic = new ActaInicioLogic();
        actaInicioLogic.saveActaInicio(diasIni, fechaIni,
            funcionesIni, horasIni, codPra_Practicante);
    }

    public static void deleteActaInicio(Long codigoIni)
        throws Exception {
        IActaInicioLogic actaInicioLogic = new ActaInicioLogic();
        actaInicioLogic.deleteActaInicio(codigoIni);
    }

    public static void updateActaInicio(Long codigoIni, String diasIni,
        Date fechaIni, String funcionesIni, Long horasIni,
        Long codPra_Practicante) throws Exception {
        IActaInicioLogic actaInicioLogic = new ActaInicioLogic();
        actaInicioLogic.updateActaInicio(codigoIni, diasIni, fechaIni,
            funcionesIni, horasIni, codPra_Practicante);
    }

    public static ActaInicio getActaInicio(Long codigoIni)
        throws Exception {
        IActaInicioLogic actaInicioLogic = new ActaInicioLogic();
        ActaInicio actaInicio = null;

        try {
            actaInicio = actaInicioLogic.getActaInicio(codigoIni);
        } catch (Exception e) {
            throw e;
        }

        return actaInicio;
    }
    
    public static List<ActaInicio> getActaInicioByPracticante(Object[] variables,
            Object[] variablesBetween, Object[] variablesBetweenDates) throws Exception {
        IActaInicioLogic actaInicioLogic = new ActaInicioLogic();
        List<ActaInicio> actasInicio = null;
        try {     	       	
            actasInicio = actaInicioLogic.findByCriteria(variables,variablesBetween,variablesBetweenDates);            
        } catch (Exception e) {
            throw e;
        }        
        return actasInicio;
    }

    public static List<ActaInicio> findByCriteriaInActaInicio(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IActaInicioLogic actaInicioLogic = new ActaInicioLogic();

        return actaInicioLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<ActaInicio> findPageActaInicio(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IActaInicioLogic actaInicioLogic = new ActaInicioLogic();

        return actaInicioLogic.findPageActaInicio(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberActaInicio() throws Exception {
        IActaInicioLogic actaInicioLogic = new ActaInicioLogic();

        return actaInicioLogic.findTotalNumberActaInicio();
    }

    public static List<ActaSeguimiento> getActaSeguimiento()
        throws Exception {
        IActaSeguimientoLogic actaSeguimientoLogic = new ActaSeguimientoLogic();

        return actaSeguimientoLogic.getActaSeguimiento();
    }
    
    public static List<ActaSeguimiento> getActaSeguimientoByPracticante(Object[] variables,
            Object[] variablesBetween, Object[] variablesBetweenDates) throws Exception {
        IActaSeguimientoLogic actaSeguimientoLogic = new ActaSeguimientoLogic();
        List<ActaSeguimiento> actasSeguimiento = null;
        try {     	       	
        	actasSeguimiento = actaSeguimientoLogic.findByCriteria(variables,variablesBetween,variablesBetweenDates);            
        } catch (Exception e) {
            throw e;
        }        
        return actasSeguimiento;
    }

    public static void saveActaSeguimiento(String accionesSeg,
        String celularTutorSeg, Date fechaSeg, String laboresSeg,
        Long codPra_Practicante) throws Exception {
        IActaSeguimientoLogic actaSeguimientoLogic = new ActaSeguimientoLogic();
        actaSeguimientoLogic.saveActaSeguimiento(accionesSeg, celularTutorSeg,
            fechaSeg, laboresSeg, codPra_Practicante);
    }

    public static void deleteActaSeguimiento(Long codSeg)
        throws Exception {
        IActaSeguimientoLogic actaSeguimientoLogic = new ActaSeguimientoLogic();
        actaSeguimientoLogic.deleteActaSeguimiento(codSeg);
    }

    public static void updateActaSeguimiento(String accionesSeg,
        String celularTutorSeg, Long codSeg, Date fechaSeg, String laboresSeg,
        Long codPra_Practicante) throws Exception {
        IActaSeguimientoLogic actaSeguimientoLogic = new ActaSeguimientoLogic();
        actaSeguimientoLogic.updateActaSeguimiento(accionesSeg,
            celularTutorSeg, codSeg, fechaSeg, laboresSeg, codPra_Practicante);
    }

    public static ActaSeguimiento getActaSeguimiento(Long codSeg)
        throws Exception {
        IActaSeguimientoLogic actaSeguimientoLogic = new ActaSeguimientoLogic();
        ActaSeguimiento actaSeguimiento = null;

        try {
            actaSeguimiento = actaSeguimientoLogic.getActaSeguimiento(codSeg);
        } catch (Exception e) {
            throw e;
        }

        return actaSeguimiento;
    }

    public static List<ActaSeguimiento> findByCriteriaInActaSeguimiento(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IActaSeguimientoLogic actaSeguimientoLogic = new ActaSeguimientoLogic();

        return actaSeguimientoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<ActaSeguimiento> findPageActaSeguimiento(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IActaSeguimientoLogic actaSeguimientoLogic = new ActaSeguimientoLogic();

        return actaSeguimientoLogic.findPageActaSeguimiento(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberActaSeguimiento()
        throws Exception {
        IActaSeguimientoLogic actaSeguimientoLogic = new ActaSeguimientoLogic();

        return actaSeguimientoLogic.findTotalNumberActaSeguimiento();
    }

    public static List<ActaSupervision> getActaSupervision()
        throws Exception {
        IActaSupervisionLogic actaSupervisionLogic = new ActaSupervisionLogic();

        return actaSupervisionLogic.getActaSupervision();
    }
    
    /*public static List<ActaSupervision> getActaSupervisionByPracticante(Object[] variables,
            Object[] variablesBetween, Object[] variablesBetweenDates) throws Exception {
        IActaSupervisionLogic actaSupervisionLogic = new ActaSupervisionLogic();
        List<ActaSupervision> actasSupervision = null;
        try {     	       	
        	actasSupervision = actaSupervisionLogic.findByCriteria(variables,variablesBetween,variablesBetweenDates);            
        } catch (Exception e) {
            throw e;
        }        
        return actasSupervision;
    }*/

    public static void saveActaSupervision(String actividadSuper,
        Date fechaSuper, Long codPra_Practicante)
        throws Exception {
        IActaSupervisionLogic actaSupervisionLogic = new ActaSupervisionLogic();
        actaSupervisionLogic.saveActaSupervision(actividadSuper,
            fechaSuper, codPra_Practicante);
    }

    public static void deleteActaSupervision(Long codSuper)
        throws Exception {
        IActaSupervisionLogic actaSupervisionLogic = new ActaSupervisionLogic();
        actaSupervisionLogic.deleteActaSupervision(codSuper);
    }

    public static void updateActaSupervision(String actividadSuper,
        Long codSuper, Date fechaSuper, Long codPra_Practicante)
        throws Exception {
        IActaSupervisionLogic actaSupervisionLogic = new ActaSupervisionLogic();
        actaSupervisionLogic.updateActaSupervision(actividadSuper, codSuper,
            fechaSuper, codPra_Practicante);
    }

    public static ActaSupervision getActaSupervision(Long codSuper)
        throws Exception {
        IActaSupervisionLogic actaSupervisionLogic = new ActaSupervisionLogic();
        ActaSupervision actaSupervision = null;
        try {
            actaSupervision = actaSupervisionLogic.getActaSupervision(codSuper);
        } catch (Exception e) {
            throw e;
        }
        return actaSupervision;
    }

    public static List<ActaSupervision> findByCriteriaInActaSupervision(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IActaSupervisionLogic actaSupervisionLogic = new ActaSupervisionLogic();

        return actaSupervisionLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<ActaSupervision> findPageActaSupervision(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IActaSupervisionLogic actaSupervisionLogic = new ActaSupervisionLogic();

        return actaSupervisionLogic.findPageActaSupervision(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberActaSupervision()
        throws Exception {
        IActaSupervisionLogic actaSupervisionLogic = new ActaSupervisionLogic();

        return actaSupervisionLogic.findTotalNumberActaSupervision();
    }

    public static List<Administrador> getAdministrador()
        throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();

        return administradorLogic.getAdministrador();
    }

    public static void saveAdministrador(Long codigoAdmin, String emailAdmin,
        String nombreAdmin, Long codigoCue_Cuenta) throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();
        administradorLogic.saveAdministrador(codigoAdmin, emailAdmin,
            nombreAdmin, codigoCue_Cuenta);
    }

    public static void deleteAdministrador(Long codigoAdmin)
        throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();
        administradorLogic.deleteAdministrador(codigoAdmin);
    }

    public static void updateAdministrador(Long codigoAdmin, String emailAdmin,
        String nombreAdmin, Long codigoCue_Cuenta) throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();
        administradorLogic.updateAdministrador(codigoAdmin, emailAdmin,
            nombreAdmin, codigoCue_Cuenta);
    }

    public static Administrador getAdministrador(Long codigoAdmin)
        throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();
        Administrador administrador = null;

        try {
            administrador = administradorLogic.getAdministrador(codigoAdmin);
        } catch (Exception e) {
            throw e;
        }

        return administrador;
    }

    public static List<Administrador> findByCriteriaInAdministrador(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();

        return administradorLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Administrador> findPageAdministrador(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();

        return administradorLogic.findPageAdministrador(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberAdministrador() throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();

        return administradorLogic.findTotalNumberAdministrador();
    }

    public static List<Archivo> getArchivo() throws Exception {
        IArchivoLogic archivoLogic = new ArchivoLogic();

        return archivoLogic.getArchivo();
    }

    public static void saveArchivo(Long codigoAr, String nombreAr, String tipoAr)
        throws Exception {
        IArchivoLogic archivoLogic = new ArchivoLogic();
        archivoLogic.saveArchivo(codigoAr, nombreAr, tipoAr);
    }

    public static void deleteArchivo(Long codigoAr) throws Exception {
        IArchivoLogic archivoLogic = new ArchivoLogic();
        archivoLogic.deleteArchivo(codigoAr);
    }

    public static void updateArchivo(Long codigoAr, String nombreAr,
        String tipoAr) throws Exception {
        IArchivoLogic archivoLogic = new ArchivoLogic();
        archivoLogic.updateArchivo(codigoAr, nombreAr, tipoAr);
    }

    public static Archivo getArchivo(Long codigoAr) throws Exception {
        IArchivoLogic archivoLogic = new ArchivoLogic();
        Archivo archivo = null;

        try {
            archivo = archivoLogic.getArchivo(codigoAr);
        } catch (Exception e) {
            throw e;
        }

        return archivo;
    }

    public static List<Archivo> findByCriteriaInArchivo(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IArchivoLogic archivoLogic = new ArchivoLogic();

        return archivoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Archivo> findPageArchivo(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IArchivoLogic archivoLogic = new ArchivoLogic();

        return archivoLogic.findPageArchivo(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberArchivo() throws Exception {
        IArchivoLogic archivoLogic = new ArchivoLogic();

        return archivoLogic.findTotalNumberArchivo();
    }

    public static List<AreaDesempeno> getAreaDesempeno()
        throws Exception {
        IAreaDesempenoLogic areaDesempenoLogic = new AreaDesempenoLogic();

        return areaDesempenoLogic.getAreaDesempeno();
    }

    public static void saveAreaDesempeno(Long codigoArea, String nombreArea)
        throws Exception {
        IAreaDesempenoLogic areaDesempenoLogic = new AreaDesempenoLogic();
        areaDesempenoLogic.saveAreaDesempeno(codigoArea, nombreArea);
    }

    public static void deleteAreaDesempeno(Long codigoArea)
        throws Exception {
        IAreaDesempenoLogic areaDesempenoLogic = new AreaDesempenoLogic();
        areaDesempenoLogic.deleteAreaDesempeno(codigoArea);
    }

    public static void updateAreaDesempeno(Long codigoArea, String nombreArea)
        throws Exception {
        IAreaDesempenoLogic areaDesempenoLogic = new AreaDesempenoLogic();
        areaDesempenoLogic.updateAreaDesempeno(codigoArea, nombreArea);
    }

    public static AreaDesempeno getAreaDesempeno(Long codigoArea)
        throws Exception {
        IAreaDesempenoLogic areaDesempenoLogic = new AreaDesempenoLogic();
        AreaDesempeno areaDesempeno = null;

        try {
            areaDesempeno = areaDesempenoLogic.getAreaDesempeno(codigoArea);
        } catch (Exception e) {
            throw e;
        }

        return areaDesempeno;
    }

    public static List<AreaDesempeno> findByCriteriaInAreaDesempeno(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IAreaDesempenoLogic areaDesempenoLogic = new AreaDesempenoLogic();

        return areaDesempenoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<AreaDesempeno> findPageAreaDesempeno(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IAreaDesempenoLogic areaDesempenoLogic = new AreaDesempenoLogic();

        return areaDesempenoLogic.findPageAreaDesempeno(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberAreaDesempeno() throws Exception {
        IAreaDesempenoLogic areaDesempenoLogic = new AreaDesempenoLogic();

        return areaDesempenoLogic.findTotalNumberAreaDesempeno();
    }

    public static List<Cuenta> getCuenta() throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();

        return cuentaLogic.getCuenta();
    }

	public static Cuenta getCuentabyUsuario(String UsuarioCue) throws Exception {
		ICuentaLogic cuentaLogic = new CuentaLogic();

		return cuentaLogic.getCuentabyUsuario(UsuarioCue);
	}

	public static void saveCuenta(String claveCue, Long estadoCue,
			Long tipoUsuario, String usuarioCue) throws Exception {
		ICuentaLogic cuentaLogic = new CuentaLogic();
		cuentaLogic.saveCuenta(claveCue, estadoCue, tipoUsuario,
				usuarioCue);
	}

    public static void deleteCuenta(Long codigoCue) throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();
        cuentaLogic.deleteCuenta(codigoCue);
    }

    public static void updateCuenta(String claveCue, Long codigoCue,
        Long estadoCue, Long tipoUsuario, String usuarioCue)
        throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();
        cuentaLogic.updateCuenta(claveCue, codigoCue, estadoCue, tipoUsuario,
            usuarioCue);
    }

    public static Cuenta getCuenta(Long codigoCue) throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();
        Cuenta cuenta = null;

        try {
            cuenta = cuentaLogic.getCuenta(codigoCue);
        } catch (Exception e) {
            throw e;
        }

        return cuenta;
    }
    
    public static Cuenta findAccount(String login,String pass) throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();      
        Cuenta cuenta = null;
        List<Cuenta> cuentas;
        try {
        	cuentas = cuentaLogic.getLogin(login, pass);
            if(cuentas != null){
            	cuenta = cuentas.get(0);
            }
        } catch (Exception e) {
            throw e;
        }

        return cuenta;
    }    

    public static List<Cuenta> findByCriteriaInCuenta(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();

        return cuentaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Cuenta> findPageCuenta(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();

        return cuentaLogic.findPageCuenta(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberCuenta() throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();

        return cuentaLogic.findTotalNumberCuenta();
    }

    public static List<Docente> getDocente() throws Exception {
        IDocenteLogic docenteLogic = new DocenteLogic();

        return docenteLogic.getDocente();
    }

    public static void saveDocente(String apellidoDocente,
        String celularDocente, Long codDocente, String emailDocente,
        String nombreDocente, String telefonoDocente, Long codigoCue_Cuenta)
        throws Exception {
        IDocenteLogic docenteLogic = new DocenteLogic();
        docenteLogic.saveDocente(apellidoDocente, celularDocente, codDocente,
            emailDocente, nombreDocente, telefonoDocente, codigoCue_Cuenta);
    }

    public static void deleteDocente(Long codDocente) throws Exception {
        IDocenteLogic docenteLogic = new DocenteLogic();
        docenteLogic.deleteDocente(codDocente);
    }

    public static void updateDocente(String apellidoDocente,
        String celularDocente, Long codDocente, String emailDocente,
        String nombreDocente, String telefonoDocente, Long codigoCue_Cuenta)
        throws Exception {
        IDocenteLogic docenteLogic = new DocenteLogic();
        docenteLogic.updateDocente(apellidoDocente, celularDocente, codDocente,
            emailDocente, nombreDocente, telefonoDocente, codigoCue_Cuenta);
    }

    public static Docente getDocente(Long codDocente) throws Exception {
        IDocenteLogic docenteLogic = new DocenteLogic();
        Docente docente = null;

        try {
            docente = docenteLogic.getDocente(codDocente);
        } catch (Exception e) {
            throw e;
        }

        return docente;
    }

    public static List<Docente> findByCriteriaInDocente(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IDocenteLogic docenteLogic = new DocenteLogic();

        return docenteLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Docente> findPageDocente(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IDocenteLogic docenteLogic = new DocenteLogic();

        return docenteLogic.findPageDocente(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberDocente() throws Exception {
        IDocenteLogic docenteLogic = new DocenteLogic();

        return docenteLogic.findTotalNumberDocente();
    }

    public static List<Empresa> getEmpresa() throws Exception {
        IEmpresaLogic empresaLogic = new EmpresaLogic();

        return empresaLogic.getEmpresa();
    }

    public static void saveEmpresa(String direccionEmp,
        String emailEmp, String nitEmp, String nombreEmp, String telefonoEmp)
        throws Exception {
        IEmpresaLogic empresaLogic = new EmpresaLogic();
        empresaLogic.saveEmpresa(direccionEmp, emailEmp, nitEmp,
            nombreEmp, telefonoEmp);
    }

    public static void deleteEmpresa(Long codigoEmp) throws Exception {
        IEmpresaLogic empresaLogic = new EmpresaLogic();
        empresaLogic.deleteEmpresa(codigoEmp);
    }

    public static void updateEmpresa(Long codigoEmp, String direccionEmp,
        String emailEmp, String nitEmp, String nombreEmp, String telefonoEmp)
        throws Exception {
        IEmpresaLogic empresaLogic = new EmpresaLogic();
        empresaLogic.updateEmpresa(codigoEmp, direccionEmp, emailEmp, nitEmp,
            nombreEmp, telefonoEmp);
    }

    public static Empresa getEmpresa(Long codigoEmp) throws Exception {
        IEmpresaLogic empresaLogic = new EmpresaLogic();
        Empresa empresa = null;

        try {
            empresa = empresaLogic.getEmpresa(codigoEmp);
        } catch (Exception e) {
            throw e;
        }

        return empresa;
    }
    
    public static List<Empresa> findByCriteriaInEmpresa(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IEmpresaLogic empresaLogic = new EmpresaLogic();

        return empresaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Empresa> findPageEmpresa(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IEmpresaLogic empresaLogic = new EmpresaLogic();

        return empresaLogic.findPageEmpresa(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberEmpresa() throws Exception {
        IEmpresaLogic empresaLogic = new EmpresaLogic();

        return empresaLogic.findTotalNumberEmpresa();
    }

    public static List<Inscripcion> getInscripcion() throws Exception {
        IInscripcionLogic inscripcionLogic = new InscripcionLogic();

        return inscripcionLogic.getInscripcion();
    }

    public static void saveInscripcion(Long codigoIns, Long codigoInsAr,
        Date fechaIns, Long codPra_Practicante) throws Exception {
        IInscripcionLogic inscripcionLogic = new InscripcionLogic();
        inscripcionLogic.saveInscripcion(codigoIns, codigoInsAr, fechaIns,
            codPra_Practicante);
    }

    public static void deleteInscripcion(Long codigoIns)
        throws Exception {
        IInscripcionLogic inscripcionLogic = new InscripcionLogic();
        inscripcionLogic.deleteInscripcion(codigoIns);
    }

    public static void updateInscripcion(Long codigoIns, Long codigoInsAr,
        Date fechaIns, Long codPra_Practicante) throws Exception {
        IInscripcionLogic inscripcionLogic = new InscripcionLogic();
        inscripcionLogic.updateInscripcion(codigoIns, codigoInsAr, fechaIns,
            codPra_Practicante);
    }

    public static Inscripcion getInscripcion(Long codigoIns)
        throws Exception {
        IInscripcionLogic inscripcionLogic = new InscripcionLogic();
        Inscripcion inscripcion = null;

        try {
            inscripcion = inscripcionLogic.getInscripcion(codigoIns);
        } catch (Exception e) {
            throw e;
        }

        return inscripcion;
    }

    public static List<Inscripcion> findByCriteriaInInscripcion(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IInscripcionLogic inscripcionLogic = new InscripcionLogic();

        return inscripcionLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Inscripcion> findPageInscripcion(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IInscripcionLogic inscripcionLogic = new InscripcionLogic();

        return inscripcionLogic.findPageInscripcion(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberInscripcion() throws Exception {
        IInscripcionLogic inscripcionLogic = new InscripcionLogic();

        return inscripcionLogic.findTotalNumberInscripcion();
    }

    public static List<Practicante> getPracticante() throws Exception {
        IPracticanteLogic practicanteLogic = new PracticanteLogic();

        return practicanteLogic.getPracticante();
    }

    public static void savePracticante(String apellidoPra, String celularPra,
        Long codPra, String emailPra, String jornadaPra, String nombrePra,
        Long semestrePra, String telFijoPra, Long codigoCue_Cuenta,
        Long codDocente_Docente, Long codigoPrograma_ProgramaAcademico)
        throws Exception {
        IPracticanteLogic practicanteLogic = new PracticanteLogic();
        practicanteLogic.savePracticante(apellidoPra, celularPra, codPra,
            emailPra, jornadaPra, nombrePra, semestrePra, telFijoPra,
            codigoCue_Cuenta, codDocente_Docente,
            codigoPrograma_ProgramaAcademico);
    }

    public static void deletePracticante(Long codPra) throws Exception {
        IPracticanteLogic practicanteLogic = new PracticanteLogic();
        practicanteLogic.deletePracticante(codPra);
    }

    public static void updatePracticante(String apellidoPra, String celularPra,
        Long codPra, String emailPra, String jornadaPra, String nombrePra,
        Long semestrePra, String telFijoPra, Long codigoCue_Cuenta,
        Long codDocente_Docente, Long codigoPrograma_ProgramaAcademico)
        throws Exception {
        IPracticanteLogic practicanteLogic = new PracticanteLogic();
        practicanteLogic.updatePracticante(apellidoPra, celularPra, codPra,
            emailPra, jornadaPra, nombrePra, semestrePra, telFijoPra,
            codigoCue_Cuenta, codDocente_Docente,
            codigoPrograma_ProgramaAcademico);
    }

    public static Practicante getPracticante(Long codPra)
        throws Exception {
        IPracticanteLogic practicanteLogic = new PracticanteLogic();
        Practicante practicante = null;

        try {
            practicante = practicanteLogic.getPracticante(codPra);
        } catch (Exception e) {
            throw e;
        }

        return practicante;
    }

    public static List<Practicante> findByCriteriaInPracticante(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IPracticanteLogic practicanteLogic = new PracticanteLogic();

        return practicanteLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Practicante> findPagePracticante(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IPracticanteLogic practicanteLogic = new PracticanteLogic();

        return practicanteLogic.findPagePracticante(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberPracticante() throws Exception {
        IPracticanteLogic practicanteLogic = new PracticanteLogic();

        return practicanteLogic.findTotalNumberPracticante();
    }

    public static List<Preinscripcion> getPreinscripcion()
        throws Exception {
        IPreinscripcionLogic preinscripcionLogic = new PreinscripcionLogic();

        return preinscripcionLogic.getPreinscripcion();
    }

	public static void savePreinscripcion(String cargoPre,
			String cargoTutorPre, String celularTutorPre,
			String descripcionPre, Long estadoPre, Date fechaFinalPre,
			Date fechaInicioPre, Date fechaPre, String laboraPre,
			String laboresPre, String lugarLaboraPre, String nombreTutorPre,
			String objetivoPre, String telefonoTutorPre, String temasPre,
			Long codigoArea_AreaDesempeno, Long codigoEmp_Empresa,
			Long codPra_Practicante) throws Exception {
		IPreinscripcionLogic preinscripcionLogic = new PreinscripcionLogic();
		preinscripcionLogic.savePreinscripcion(cargoPre, cargoTutorPre,
				celularTutorPre, descripcionPre, estadoPre, fechaFinalPre,
				fechaInicioPre, fechaPre, laboraPre, laboresPre,
				lugarLaboraPre, nombreTutorPre, objetivoPre, telefonoTutorPre,
				temasPre, codigoArea_AreaDesempeno, codigoEmp_Empresa,
				codPra_Practicante);
	}

    public static void deletePreinscripcion(Long codPre)
        throws Exception {
        IPreinscripcionLogic preinscripcionLogic = new PreinscripcionLogic();
        preinscripcionLogic.deletePreinscripcion(codPre);
    }

	public static void updatePreinscripcion(String cargoPre,
			String cargoTutorPre, String celularTutorPre,
			String descripcionPre, Long estadoPre, Date fechaFinalPre,
			Date fechaInicioPre, Date fechaPre, String laboraPre,
			String laboresPre, String lugarLaboraPre, String nombreTutorPre,
			String objetivoPre, String telefonoTutorPre, String temasPre,
			Long codigoArea_AreaDesempeno, Long codigoEmp_Empresa,
			Long codPra_Practicante) throws Exception {
		IPreinscripcionLogic preinscripcionLogic = new PreinscripcionLogic();
		preinscripcionLogic.updatePreinscripcion(cargoPre, cargoTutorPre,
				celularTutorPre, descripcionPre, estadoPre, fechaFinalPre,
				fechaInicioPre, fechaPre, laboraPre, laboresPre,
				lugarLaboraPre, nombreTutorPre, objetivoPre, telefonoTutorPre,
				temasPre, codigoArea_AreaDesempeno, codigoEmp_Empresa,
				codPra_Practicante);
	}

	public static void updatePreinscripcion(Long estadoPre,
			Long codPra_Practicante) throws Exception {
		IPreinscripcionLogic preinscripcionLogic = new PreinscripcionLogic();
		preinscripcionLogic.updatePreinscripcion(estadoPre, codPra_Practicante);
	}

    public static Preinscripcion getPreinscripcion(Long codPra)
        throws Exception {
        IPreinscripcionLogic preinscripcionLogic = new PreinscripcionLogic();
        Preinscripcion preinscripcion = null;

        try {
            preinscripcion = preinscripcionLogic.getPreinscripcion(codPra);
        } catch (Exception e) {
            throw e;
        }

        return preinscripcion;
    }

    public static List<Preinscripcion> findByCriteriaInPreinscripcion(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IPreinscripcionLogic preinscripcionLogic = new PreinscripcionLogic();

        return preinscripcionLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Preinscripcion> findPagePreinscripcion(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IPreinscripcionLogic preinscripcionLogic = new PreinscripcionLogic();

        return preinscripcionLogic.findPagePreinscripcion(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberPreinscripcion()
        throws Exception {
        IPreinscripcionLogic preinscripcionLogic = new PreinscripcionLogic();

        return preinscripcionLogic.findTotalNumberPreinscripcion();
    }

    public static List<ProgramaAcademico> getProgramaAcademico()
        throws Exception {
        IProgramaAcademicoLogic programaAcademicoLogic = new ProgramaAcademicoLogic();

        return programaAcademicoLogic.getProgramaAcademico();
    }

    public static void saveProgramaAcademico(String nombrePrograma) throws Exception {
        IProgramaAcademicoLogic programaAcademicoLogic = new ProgramaAcademicoLogic();
        programaAcademicoLogic.saveProgramaAcademico(nombrePrograma);
    }

    public static void deleteProgramaAcademico(Long codigoPrograma)
        throws Exception {
        IProgramaAcademicoLogic programaAcademicoLogic = new ProgramaAcademicoLogic();
        programaAcademicoLogic.deleteProgramaAcademico(codigoPrograma);
    }

    public static void updateProgramaAcademico(Long codigoPrograma,
        String nombrePrograma) throws Exception {
        IProgramaAcademicoLogic programaAcademicoLogic = new ProgramaAcademicoLogic();
        programaAcademicoLogic.updateProgramaAcademico(codigoPrograma,
            nombrePrograma);
    }

    public static ProgramaAcademico getProgramaAcademico(Long codigoPrograma)
        throws Exception {
        IProgramaAcademicoLogic programaAcademicoLogic = new ProgramaAcademicoLogic();
        ProgramaAcademico programaAcademico = null;

        try {
            programaAcademico = programaAcademicoLogic.getProgramaAcademico(codigoPrograma);
        } catch (Exception e) {
            throw e;
        }

        return programaAcademico;
    }

    public static List<ProgramaAcademico> findByCriteriaInProgramaAcademico(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IProgramaAcademicoLogic programaAcademicoLogic = new ProgramaAcademicoLogic();

        return programaAcademicoLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<ProgramaAcademico> findPageProgramaAcademico(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IProgramaAcademicoLogic programaAcademicoLogic = new ProgramaAcademicoLogic();

        return programaAcademicoLogic.findPageProgramaAcademico(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberProgramaAcademico()
        throws Exception {
        IProgramaAcademicoLogic programaAcademicoLogic = new ProgramaAcademicoLogic();

        return programaAcademicoLogic.findTotalNumberProgramaAcademico();
    }
    
}
